NAME¶

perf-top - System profiling tool.

SYNOPSIS¶

perf top [-e <EVENT> | --event=EVENT] [<options>]

DESCRIPTION¶

This command generates and displays a performance counter profile in real time.

OPTIONS¶

-a, --all-cpus

-c <count>, --count=<count>

-C <cpu-list>, --cpu=<cpu>

-d <seconds>, --delay=<seconds>

-e <event>, --event=<event>

-E <entries>, --entries=<entries>

-f <count>, --count-filter=<count>

--group

-F <freq>, --freq=<freq>

-i, --inherit

-k <path>, --vmlinux=<path>

--ignore-vmlinux

-m <pages>, --mmap-pages=<pages>

-p <pid>, --pid=<pid>

-t <tid>, --tid=<tid>

-u, --uid=

-r <priority>, --realtime=<priority>

--sym-annotate=<symbol>

-K, --hide_kernel_symbols

-U, --hide_user_symbols

--demangle-kernel

-D, --dump-symtab

-v, --verbose

-z, --zero

-s, --sort

--fields=

By default, every sort keys not specified in --field will be appended
automatically.

-n, --show-nr-samples

--show-total-period

--dsos

--comms

--symbols

-M, --disassembler-style=

--source

--asm-raw

-g

--call-graph [mode,type,min[,limit],order[,key][,branch]]

--children

--max-stack

Default: /proc/sys/kernel/perf_event_max_stack when present, 127 otherwise.

--ignore-callees=<regex>

--percent-limit

--percentage

"relative" means it's relative to filtered entries only so that the
sum of shown entries will be always 100%. "absolute" means it retains
the original value before and after the filter is applied.

-w, --column-widths=<width[,width...]>

--proc-map-timeout

-b, --branch-any

-j, --branch-filter

The option requires at least one branch type among any, any_call, any_ret, ind_call, cond.
The privilege levels may be omitted, in which case, the privilege levels of the associated
event are applied to the branch filter. Both kernel (k) and hypervisor (hv) privilege
levels are subject to permissions.  When sampling on multiple events, branch stack sampling
is enabled for all the sampling events. The sampled branch type is the same for all events.
The various filters must be specified as a comma separated list: --branch-filter any_ret,u,k
Note that this feature may not be available on all processors.

--raw-trace

--hierarchy

--overwrite

--force

--num-thread-synthesize

INTERACTIVE PROMPTING KEYS¶

[d]

[e]

[E]

[f]

[F]

[s]

[S]

[K]

[U]

[z]

[qQ]

Pressing any unmapped key displays a menu, and prompts for input.

OVERHEAD CALCULATION¶

The overhead can be shown in two columns as Children and Self when perf collects callchains. The self overhead is simply calculated by adding all period values of the entry - usually a function (symbol). This is the value that perf shows traditionally and sum of all the self overhead values should be 100%.

The children overhead is calculated by adding all period values of the child functions so that it can show the total overhead of the higher level functions even if they don’t directly execute much. Children here means functions that are called from another (parent) function.

It might be confusing that the sum of all the children overhead values exceeds 100% since each of them is already an accumulation of self overhead of its child functions. But with this enabled, users can find which function has the most overhead even if samples are spread over the children.

Consider the following example; there are three functions like below.

.ft C
void foo(void) {


    /* do something */
}
void bar(void) {


    /* do something */


    foo();
}
int main(void) {


    bar()


    return 0;
}
.ft

In this case foo is a child of bar, and bar is an immediate child of main so foo also is a child of main. In other words, main is a parent of foo and bar, and bar is a parent of foo.

Suppose all samples are recorded in foo and bar only. When it’s recorded with callchains the output will show something like below in the usual (self-overhead-only) output of perf report:

.ft C
Overhead  Symbol
........  .....................


  60.00%  foo


          |


          --- foo


              bar


              main


              __libc_start_main


  40.00%  bar


          |


          --- bar


              main


              __libc_start_main
.ft

When the --children option is enabled, the self overhead values of child functions (i.e. foo and bar) are added to the parents to calculate the children overhead. In this case the report could be displayed as:

.ft C
Children      Self  Symbol
........  ........  ....................


 100.00%     0.00%  __libc_start_main


          |


          --- __libc_start_main


 100.00%     0.00%  main


          |


          --- main


              __libc_start_main


 100.00%    40.00%  bar


          |


          --- bar


              main


              __libc_start_main


  60.00%    60.00%  foo


          |


          --- foo


              bar


              main


              __libc_start_main
.ft

In the above output, the self overhead of foo (60%) was add to the children overhead of bar, main and __libc_start_main. Likewise, the self overhead of bar (40%) was added to the children overhead of main and \_\_libc_start_main.

So \_\_libc_start_main and main are shown first since they have same (100%) children overhead (even though they have zero self overhead) and they are the parents of foo and bar.

Since v3.16 the children overhead is shown by default and the output is sorted by its values. The children overhead is disabled by specifying --no-children option on the command line or by adding report.children = false or top.children = false in the perf config file.

SEE ALSO¶

perf-stat(1), perf-list(1), perf-report(1)